/* 
 * File:   main.cpp
 * Author: martin
 *
 * Created on September 14, 2012, 7:23 PM
 */

#include <cstdlib>
#include<fstream>
#include<cassert>
#include<iostream>
#include<sstream>
#include<cstring>
#include"ConversorCadena.h"
#include"PalabraAleatoria.h"
#include<stdio.h>
#include"ArchivoPalabraAleatoria.h"
#include<unistd.h>
#include<sys/types.h>

using namespace std;

#define IMP(v) \
cout<<"->"<<#v<<" es= "<<v<<endl;
#define TEST(i) \
cout<<"->test "<<i<<" finalizo correctamente \n";

void testAbrirArchivo(){

    ofstream salida("largosComoTexto.txt");
    int numero= 99;
    string s;
    stringstream out;
    char* numero_c= new char[9];
    
    
    out<<numero;
    s= out.str();
    IMP(s);
    strcpy(numero_c,s.c_str());
    IMP(numero_c);
    IMP(strlen(numero_c));
    
    salida.close();
    
}//FUNCIONA

void testConversorCadena(){
    ConversorCadena* cc= new ConversorCadena;
    
    char *c= cc->convertir(10);
    IMP(c);
    
    delete cc;
}//FUNCIONA

void testPalabraAleatoria(){
    PalabraAleatoria pa1("martin",21);
    PalabraAleatoria pa2("mateo",18);
    PalabraAleatoria pa3("arbol",21);
    
    assert(pa2<pa1);
    TEST(1);
    
    assert(pa3<pa1);
    TEST(2);
    
    assert(pa1>pa2);
    TEST(3);
    
    assert(pa1>pa3);
    TEST(4);
    
    assert( sizeof(pa1)== PalabraAleatoria::TAM_REGISTRO );
    TEST(5);
    
}//FUNCIONA

void testEjecutarComandoShell(){
    system("ls");
    return;
}

void testBufferPalabraAleatoria(){
    PalabraAleatoria* pas= (PalabraAleatoria*)malloc(PalabraAleatoria::TAM_REGISTRO*8);
    ofstream salida("palabrasAleatorias");
    const unsigned int TAM_BUFFER= PalabraAleatoria::TAM_REGISTRO*8;
    char* buffer= new char[TAM_BUFFER];
    ifstream entrada;
    PalabraAleatoria* pa1= new PalabraAleatoria("martin",21);
    PalabraAleatoria* pa2= new PalabraAleatoria("mateo",18);
    unsigned int tamArchivo;
    unsigned int cantRegistros;
    
    salida.write((char*)pa1,PalabraAleatoria::TAM_REGISTRO);
    salida.write((char*)pa2,PalabraAleatoria::TAM_REGISTRO);
    salida.close();
    
    entrada.open("palabrasAleatorias");
    entrada.seekg(0,fstream::end);
    tamArchivo= entrada.tellg();
    IMP(tamArchivo);
    cantRegistros= tamArchivo/PalabraAleatoria::TAM_REGISTRO;
    IMP(cantRegistros);
    entrada.seekg(0,fstream::beg);
    entrada.read(buffer,TAM_BUFFER);
    pas= (PalabraAleatoria*)buffer;
    IMP( pas[0].getPalabra() );
    
    delete[] buffer;
    delete pa1;
    delete pa2;
}//FUNCIONA

void testAgregarRegistros(){
    
    PalabraAleatoria* pas= (PalabraAleatoria*)malloc(PalabraAleatoria::TAM_REGISTRO*8);
    ofstream salida("palabrasAleatorias",fstream::app);
    const unsigned int TAM_BUFFER= PalabraAleatoria::TAM_REGISTRO*8;
    ifstream entrada;
    PalabraAleatoria* pa1= new PalabraAleatoria("hector",51);
    unsigned int tamArchivo;
    unsigned int cantRegistros;
    
    salida.write((char*)pa1,PalabraAleatoria::TAM_REGISTRO);
    salida.close();
    
    entrada.open("palabrasAleatorias");
    entrada.seekg(0,fstream::end);
    tamArchivo= entrada.tellg();
    IMP(tamArchivo);
    cantRegistros= tamArchivo/PalabraAleatoria::TAM_REGISTRO;
    IMP(cantRegistros);
    
    delete pa1;
}//FUNCIONA

void testGuardarUnNoPuntero(){
    ofstream salida("noPunteros");
    PalabraAleatoria pa("sonia",50);
    char* buffer= new char[PalabraAleatoria::TAM_REGISTRO];
    PalabraAleatoria* leido= (PalabraAleatoria*)malloc(PalabraAleatoria::TAM_REGISTRO);
    ifstream entrada;
    
    salida.write((char*)&pa,PalabraAleatoria::TAM_REGISTRO);
    salida.close();
    
    entrada.open("noPunteros",fstream::binary);
    entrada.read(buffer,32);
    leido= (PalabraAleatoria*)buffer;
    IMP(leido->getPalabra());
    
    delete buffer;
    
}//FUNCIONA

void testGuardarPropio(){
    ofstream salida("guardadosPropios",fstream::binary);
    PalabraAleatoria pa1("martin",21),pa2("mateo",18),pa3("hector",52);
    ifstream entrada;
    PalabraAleatoria* leidos= (PalabraAleatoria*)malloc(PalabraAleatoria::TAM_REGISTRO*3);
    
    pa1.guardar(&salida);
    pa2.guardar(&salida);
    pa3.guardar(&salida);
    
    salida.close();
    entrada.open("guardadosPropios",fstream::binary);
    entrada.read((char*)leidos,PalabraAleatoria::TAM_REGISTRO*3);
    
    for(int i=0;i<3;i++)
        IMP(leidos[i].getPalabra());
    
    delete[] leidos;
    
}//FUNCIONA

void testLevantarMultiplesRegistros(){
    ofstream salida("guardadosPropios",fstream::binary);
    PalabraAleatoria pa1("martin",21),pa2("mateo",18),pa3("hector",52);
    ifstream entrada;
    PalabraAleatoria* leidos= (PalabraAleatoria*)malloc(PalabraAleatoria::TAM_REGISTRO*3);
    
    pa1.guardar(&salida);
    pa2.guardar(&salida);
    pa3.guardar(&salida);
    
    salida.close();
    entrada.open("guardadosPropios");
    entrada.read((char*)leidos,PalabraAleatoria::TAM_REGISTRO*4);
    
    for(int i=0;i<3;i++)
        IMP(leidos[i].getPalabra());
    
    IMP(entrada.eof());
    IMP(entrada.tellg());
    entrada.seekg(0,ifstream::end);
    IMP(entrada.tellg());
    
    entrada.close();
    delete[] leidos;
}//FUNCIONA

void testCrearArchivoApp(){
    ofstream salida("archivoNuevoApp",fstream::app);
    IMP(salida.is_open());
    
    salida.close();
}//FUNCIONA

void agregarAlFinalSinApp(){
    ofstream salida("guardadosPropios",fstream::binary);
    salida.seekp(0,fstream::end);
    
    IMP(salida.tellp());
    
    salida.close();
}//NO FUNCIONA

void testAppend(){
    testGuardarPropio();
    
    ofstream salida("guardadosPropios",fstream::app);
    IMP(salida.tellp());
    
    salida.close();
    
    ifstream entrada("guardadosPropios",fstream::binary);
    IMP(entrada.tellg());
    
    entrada.close();
}//FUNCIONA

void testArchivoPalabraAleatoria(){
    ArchivoPalabraAleatoria apa;
    PalabraAleatoria pa1("martin",21);
    
    apa.abrirEscritura("archivoPalabraAleatoria");
    apa.guardar(&pa1,1);
    
    IMP(apa.getTamanioArchivo());
    
    
}//FUNCIONA

void testLeerArchivoPalabraAleatoria(){
    ArchivoPalabraAleatoria apa;
    
    int resultadoApertura;
    resultadoApertura= apa.abrirLectura("archivoPalabraAleatoria");
    IMP(apa.getTamanioArchivo());
    assert(apa.getTamanioArchivo()== 64);
    assert(resultadoApertura== ArchivoPalabraAleatoria::EXITO);
}//FUNCIONA

void testArchivoPalabraAleatoriaVariado(){
    
    const unsigned long CANT_REG= 3;
    unsigned int cantReg= 3;
    ArchivoPalabraAleatoria apa;
    PalabraAleatoria pas[CANT_REG];
    pas[0].setIdentificador(21);
    pas[0].setPalabra("martin");
    pas[1].setIdentificador(19);
    pas[1].setPalabra("mateo");
    pas[2].setIdentificador(52);
    pas[2].setPalabra("hector");
    PalabraAleatoria* buffer= (PalabraAleatoria*)malloc(CANT_REG*PalabraAleatoria::TAM_REGISTRO);
    
    int resultadoApertura;
    resultadoApertura= apa.abrirEscritura("apa1");
    assert(resultadoApertura== ArchivoPalabraAleatoria::EXITO);
    TEST(1);
    apa.limpiar();
    
    int resultadoEscritura;
    resultadoEscritura= apa.guardar(pas,CANT_REG);
    assert(resultadoEscritura== ArchivoPalabraAleatoria::EXITO);
    TEST(2);
    
    assert(apa.getCantidadRegistros()== CANT_REG);
    TEST(3);
    
    resultadoApertura= apa.abrirLectura("apa1");
    assert(resultadoApertura== ArchivoPalabraAleatoria::EXITO);
    TEST(4);
    
    int resultadoLectura;
    resultadoLectura= apa.cargar(buffer,cantReg);
    assert(resultadoLectura== ArchivoPalabraAleatoria::EXITO);
    assert(cantReg== CANT_REG);
    IMP(buffer[0].getPalabra());
    TEST(5);
    
    delete[] buffer;
}//FUNCIONA

void testTruncamiento(){
    int resultadoTruncamiento= 1;
    int tamanioArchivo;
    
    resultadoTruncamiento= truncate("archivoPalabraAleatoria",32);
    
    ifstream entrada("archivoPalabraAleatoria");
    entrada.seekg(0,fstream::end);
    tamanioArchivo= entrada.tellg();
    IMP(tamanioArchivo);
    
    entrada.close();
    
    
}//FUNCIONA

void testEscrituraTabulada(){
    ofstream salida("escrituraTabulada.txt");
    char nombre[20]= "martin";
    char profesion[20]= "ingeniero";
    
    salida<<nombre;
    salida<<(char)9;
    salida<<profesion;
    
    salida.close();
}

void testGranTruncamiento(){
    ofstream salida("archivoTruncado");
    salida.close();
    
    truncate("archivoTruncado",128);
    salida.open("archivoTruncado",fstream::app);
    IMP(salida.tellp());
    
    const unsigned int CANT_ESCRITURAS= 32;
    for(int i=0;i<CANT_ESCRITURAS;i++)
        salida<<(char)(i+67);
    
    salida.close();
    
    char lectura;
    ifstream entrada("archivoTruncado");
    entrada.seekg(128,fstream::beg);
    for(int i=0;i<CANT_ESCRITURAS;i++){
        entrada>>lectura;
        IMP(lectura);
    }
    
    entrada.close();
}

int main(int argc, char** argv) {
    testGranTruncamiento();
}

